{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  神经元\n",
    "  \n",
    "    \n",
    "  让我们来看一个经典的神经网络。\n",
    "  一般来说，作为人工神经元模型应具各三个要素:\n",
    "1.每个神经元的输入有一个权重wi用来表示第i个神经元神经元的连接权重。 \n",
    "2.各个信号信息乘以权重得到的信号累加器，θ表示阀值。 \n",
    "3.激活函数。作用：数值上挤压，几何上变形。\n",
    "![Markdown](http://i2.tiimg.com/611786/1fb0a7abe98b90af.png)\n",
    "其中（x1,x2,x3……）为神经元的初始输入，ui为神经元的组合输入，θ为阀值，vi为组合输入与阀值计算之后的输入，\n",
    "f(x)为激励函数，激活函数，挤压函数都可以。yi是这个神经元最后的输出， \n",
    "   每个连接线对应一个不同的权重（其值称为权值），这是需要训练得到的。  \n",
    "   用直线将点分开很容易，但是要是这样的呢？：\n",
    "   ![Markdown](http://i2.tiimg.com/611786/08ca7f24cecf698e.png)\n",
    "   我们可以这样：把他改成非线性的不就ok了?例如先画个圆？\n",
    "   ![Markdown](http://i2.tiimg.com/611786/911c5be9a4ee69e9.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 前馈神经网络数学表示\n",
    "神经元将每个输入乘以权重，然后相加，再通过中间层神经元内部的S形表示的非线性函数（即1/（1+e^（-x））（用于再输出前修改神经元的值），最终传递给其输出。\n",
    "![Markdown](http://i2.tiimg.com/611786/21df6347de1c86e5.png)\n",
    "\n",
    "  \n",
    "  下图的神经网络是由简单线性模型构成的堆叠，其间由非线性函数进行分割。\n",
    "![Markdown](http://i2.tiimg.com/611786/992cbab2a33d04b2.png)\n",
    "在此图中，输入层是四维向量，全连接层可以看作是4→6维的线性变化（h = x·W），然后，在作为输入传递到下一层之前，h中每个值都要由非线性函数g作一定的变换。\n",
    "第一层隐层：从输入到输出：过程(g（x·W1))·W2\n",
    "  \n",
    "  最简单的神经网络称作感知器：NN（x） = x·W+b\n",
    "  带有单一隐层的错层感知器：NN（x） =g（xW1+b1）·W2 + b2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  常见的非线性函数\n",
    "  \n",
    "  非线性函数可以选取很多不同的形式，在什么情况下使用什么非线性函数现在还没有很好的理论。\n",
    "  \n",
    "  （1）sigmoid激活函数。Sigmoid函数是一个在生物学中常见的S型函数，也称为S型生长曲线。在信息科学中，由于其单增以及反函数单增等性质，Sigmoid函数常被用作神经网络的阈值函数，将变量映射到0,1之间。$$\\sigma(x) = \\frac {1}{1+{\\rm e}^{-x}}$$\n",
    "  \n",
    "  (2)tanh(双曲正切）函数：y=tanh x；定义域：R，值域：(-1,1)。y=tanh x是一个奇函数，其函数图像为过原点并且穿越Ⅰ、Ⅲ象限的严格单调递增曲线，其图像被限制在两水平渐近线y=1和y=-1之间。$$\\tanh(x) = \\frac {{\\rm e}^{2x}-1}{{\\rm e}^{2x}+1}$$\n",
    "  \n",
    "  （3）hard tanh 能够更快地计算 并得到导数。当x小于-1，函数值委-1，当x大于1，函数值委1，当x为其他时函数值为x本身\n",
    "  \n",
    "  （4）ReLU修正线性单元$$ReLU(x) = \\max（0，x）$$\n",
    "  ![Markdown](http://i1.fuimg.com/611786/07bd416872a6e0a3.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8807970779778823"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "def sigmoid(Z):\n",
    "  return 1/(1+np.exp(-Z))\n",
    "def relu(Z):\n",
    "  return np.maximum(0,Z)\n",
    " \n",
    "def sigmoid_backward(dA, Z):\n",
    "  sig = sigmoid(Z)\n",
    "  return dA * sig * (1 - sig)\n",
    "def relu_backward(dA, Z):\n",
    "  dZ = np.array(dA, copy = True)\n",
    "  dZ[Z <= 0] = 0;\n",
    "  return dZ;\n",
    "sigmoid(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 损失函数\n",
    "  \n",
    "  损失函数$$L( \\hat{y} , y ) $$,表示真实输出为y时候，预测结果为$\\hat{y}$的损失。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 防止过拟合：正则化与丢弃\n",
    "  正则化：L2,L1,弹性网络\n",
    "  另一种防止神经网络过度拟合训练数据有效技术是丢弃法训练。丢弃法旨在防止网络学习依赖于特定权重，在对每个训练样本进行随机梯度训练时，它会随机丢弃网络（或特定层）中一半的神经元。\n",
    "  ![Markdown](http://i2.tiimg.com/611786/7e686ef15dc71151.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  相似和距离层\n",
    "  \n",
    "  通过两个向量计算一个标量，一次反映两个向量之间的相似性、兼容性或距离。\n",
    "  \n",
    "  （1）点积 $$sim_{dot}(u,v) = u\\cdot v$$  \n",
    "  （2）欧式距离 $$dist_{euclidean}(u,v) = \\sqrt{(u-v)\\cdot (u-v)}$$  注意yige距离度量，相似度。小的值则代表相似向量，大的值表示不相似。  \n",
    "  （3）可训练形式 使用一个参数化函数来进行训练以产生所需相似度。常见的可训练相似度函数时双线性形式。$$sim_{bilinear}(u,v) = u\\cdot M\\cdot v$$ 其中M是一个需要被训练的参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  优化算法的选择\n",
    "  \n",
    "## 初始化  \n",
    "目标函数的非凸性可能意味着优化过程陷于局部极小点，所以从不同的初始点开始（比如，参数的不同随机值）可能会产生不同的结果。\n",
    "## 重启与集成\n",
    "  \n",
    "  运行训练过程多次、每次都进行随机初始化， 并在开发集中选择最好的一个，这种方法叫做随机重启。\n",
    "  模型集成：不用单个模型来预测（例如，通过不同的模型多数投票）可以提高预测精度\n",
    "  两种情况下梯度消失经常出现，一是在深层网络中，二是采用了不合适的损失函数，比如sigmoid。梯度爆炸一般出现在深层网络和权值初始化值太大的情况下，下面分别从这两个角度分析梯度消失和爆炸的原因。\n",
    "  梯度消失：非常接近于0 \n",
    "  梯度爆炸：变得非常高。\n",
    "  ##  梯度消失和梯度爆炸\n",
    "\n",
    "  解决方法：1让网络变浅，逐步训练\n",
    "  层数比较多的神经网络模型在训练的时候会出现梯度消失(gradient vanishing problem)和梯度爆炸(gradient exploding problem)问题。梯度消失问题和梯度爆炸问题一般会随着网络层数的增加变得越来越明显。 \n",
    "例如，对于含有3个隐藏层的神经网络，梯度消失问题发生时，靠近输出层的hidden layer 3的权值更新相对正常，但是靠近输入层的hidden layer1的权值更新会变得很慢，导致靠近输入层的隐藏层权值几乎不变，扔接近于初始化的权值。这就导致hidden layer 1 相当于只是一个映射层，对所有的输入做了一个函数映射，这时此深度神经网络的学习就等价于只有后几层的隐藏层网络在学习。梯度爆炸的情况是：当初始的权值过大，靠近输入层的hidden layer 1的权值变化比靠近输出层的hidden layer 3的权值变化更快，就会引起梯度爆炸的问题。 \n",
    "https://blog.csdn.net/qq_17130909/article/details/80582226 里面有一举例，比较形象，可以作为参考\n",
    "##  饱和神经元 和死神经元\n",
    "  \n",
    "  饱和神经元：梯度较小，应该避免\n",
    "  \n",
    "## 学习率 \n",
    "  \n",
    "  应该从范围【0，1】内尝试初识学习率，比如0.001，0.01，0.1，1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 神经网络代码示例\n",
    "## 数据样本的产生\n",
    "  \n",
    "  为了凸显一下神经网络强大的空间分割能力，我们打算产生出一部分对于线性分类器不那么容易分割的样本点，比如说我们生成一份螺旋状分布的样本点，如下：紫色，红色和黄色分布代表不同的3种类别。\n",
    "一般来说，拿到数据都要做预处理，包括之前提到的去均值和方差归一化。不过我们构造的数据幅度已经在-1到1之间了，所以这里不用做这个操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "N = 100 # 每个类中的样本点\n",
    "D = 2 # 维度\n",
    "K = 3 # 类别个数\n",
    "X = np.zeros((N*K,D)) # 样本input 2维\n",
    "y = np.zeros(N*K, dtype='uint8') # 类别标签\n",
    "for j in range(K):\n",
    "  ix = range(N*j,N*(j+1))#当j为0 100*0，100*1\n",
    "  r = np.linspace(0.0,1,N) # 0-1的100个数\n",
    "  t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # 0到4的100个数+100个随机数*0.2\n",
    "  X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]#数组转换成矩阵\n",
    "  y[ix] = j\n",
    "# 可视化一下我们的样本点\n",
    "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用Softmax线性分类器\n",
    "### 初始化参数、计算Wx+b、再经过softmax函数\n",
    "我们先在训练集上用softmax线性分类器试试。如我们在之前的章节提到的，我们这里用的softmax分类器，使用的是一个线性的得分函数/score function，使用的损失函数是交叉熵损失/cross-entropy loss。包含的参数包括得分函数里面用到的权重矩阵W和偏移量b，我们先随机初始化这些参数。\n",
    "softmax函数的公式是这种形式：$$S_{i} = \\frac{e^{f_{y{i}}}}{ \\sum_{j}e^{f_{j}}}$$  $S_{i}$代表的是第i个神经元的输出。使得每一个输出分量变成一个概率值，所有输出分量的概率之和为1。\n",
    "![Markdown](http://i1.fuimg.com/611786/e236d3c9ffe5cc85.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "[ 3.46369005e-05 -1.05994147e-04  1.22370999e-06]\n",
      "(300, 3)\n",
      "(300, 3)\n",
      "[0.33335267 0.3333058  0.33334153]\n"
     ]
    }
   ],
   "source": [
    "#随机初始化参数\n",
    "import numpy as np\n",
    "#D=2表示维度，K=3表示类别数\n",
    "W = 0.01 * np.random.randn(D,K)#2*3维度\n",
    "print(W.shape)\n",
    "b = np.zeros((1,K))\n",
    "#使用得分函数计算得分\n",
    "scores = np.dot(X, W) + b#X是300*2维度\n",
    "print(scores[1])\n",
    "print(scores.shape)\n",
    "# 根据上面计算得到的得分scores，我们计算以下各个类别上的概率：\n",
    "exp_scores = np.exp(scores)\n",
    "# 归一化\n",
    "probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)#按行累和\n",
    "print(probs.shape)\n",
    "print(probs[1])#第一个点在三个类别上面的概率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.010762  , -0.01082674,  0.02730299],\n",
       "       [-0.007377  , -0.00417482, -0.00859946]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# print( np.sum(exp_scores, axis=1, keepdims=True))\n",
    "np.random.randn(D,K)*0.01"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在我们给的这个例子中，我们有2个2维点集，所以做完乘法过后，矩阵得分scores其实是一个[300*3]的矩阵，每一行都给出对应3各类别(紫，红，黄)的得分。\n",
    "在我们的例子中，我们最后得到了一个[300 *3]的概率矩阵prob，其中每一行都包含属于3个类别的概率。然后我们就可以计算完整的互熵损失了\n",
    "### 计算损失\n",
    "  \n",
    "  然后我们就要开始使用我们的损失函数计算损失了，我们之前也提到过，损失函数计算出来的结果代表着预测结果和真实结果之间的吻合度，我们的目标是最小化这个结果。直观一点理解，我们希望对每个样本而言，对应正确类别的得分高于其他类别的得分，如果满足这个条件，那么损失函数计算的结果是一个比较低的值，如果判定的类别不是正确类别，则结果值会很高。softmax分类器里面，使用的损失函数（为了解决分类的问题）是交叉熵损失。假设f是得分向量，那么我们的交叉熵损失是用如下的形式定义的：$$L_{i} = -\\log(\\frac{e^{f_{y{i}}}}{ \\sum_{j}e^{f_{j}}})$$\n",
    "  我们使用fj来代表得分向量f的第j个元素值。如果判定类别是错误类别，那么上述公式的结果就会趋于无穷，也就是说损失相当相当大，相反，如果判定类别正确，那么损失就接近log(1)=0。这和我们直观理解上要最小化损失是完全吻合的。\n",
    "  ![Markdown](http://i1.fuimg.com/611786/bf9a761693e21a58.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算梯度与梯度回传  \n",
    "  \n",
    "  我们能够用损失函数评估预测值与真实值之间的差距，下一步要做的事情自然是最小化这个值。我们用传统的梯度下降来解决这个问题。多解释一句，梯度下降的过程是：我们先选取一组随机参数作为初始值，然后计算损失函数在这组参数上的梯度(负梯度的方向表明了损失函数减小的方向)，接着我们朝着负梯度的方向迭代和更新参数，不断重复这个过程直至损失函数最小化。为了清楚一点说明这个问题，我们引入一个中间变量p，它是归一化后的概率向量，如下：\n",
    "  $$P_{k} = \\frac{e^{f_{k}}}{ \\sum_{j}e^{f_{j}}}$$  \n",
    "  $$L_{i} = -\\log(P_{y_{i}})$$  \n",
    "  我们现在希望知道朝着哪个方向调整权重能够减小损失，也就是说，我们需要计算梯度∂Li/∂fk。损失Li从p计算而来，再退一步，依赖于f。于是我们又要做高数题，使用链式求导法则了，不过梯度的结果倒是非常简单：  左边的求导为  \n",
    "  $$\\partial {L_{i}}/\\partial {f_{k}} = P_{k}-1(y_{i}=k)$$  \n",
    "  解释一下，公式的最后一个部分表示yi=k的时候，取值为1。整个公式其实非常的优雅和简单。假设我们计算的概率p=[0.2, 0.3, 0.5]，而中间的类别才是真实的结果类别。根据梯度求解公式，我们得到梯度df=[0.2,−0.7,0.5]。我们想想梯度的含义，其实这个结果是可解释性非常高的：大家都知道，梯度是最快上升方向，我们减掉它乘以步长才会让损失函数值减小。第1项和第3项(其实就是不正确的类别项)梯度为正，表明增加它们只会让最后的损失/loss增大，而我们的目标是减小loss；中间的梯度项-0.7其实再告诉我们，增加这一项，能减小损失Li，达到我们最终的目的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "梯度回传：https://www.zhihu.com/question/27239198?rf=24827633"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0: loss 1.098032\n",
      "iteration 10: loss 0.899966\n",
      "iteration 20: loss 0.826377\n",
      "iteration 30: loss 0.792735\n",
      "iteration 40: loss 0.775023\n",
      "iteration 50: loss 0.764790\n",
      "iteration 60: loss 0.758487\n",
      "iteration 70: loss 0.754424\n",
      "iteration 80: loss 0.751713\n",
      "iteration 90: loss 0.749857\n",
      "iteration 100: loss 0.748560\n",
      "iteration 110: loss 0.747639\n",
      "iteration 120: loss 0.746976\n",
      "iteration 130: loss 0.746494\n",
      "iteration 140: loss 0.746139\n",
      "iteration 150: loss 0.745878\n",
      "iteration 160: loss 0.745683\n",
      "iteration 170: loss 0.745537\n",
      "iteration 180: loss 0.745428\n",
      "iteration 190: loss 0.745345\n"
     ]
    }
   ],
   "source": [
    "#代码部分组一起，训练线性分类器\n",
    "#随机初始化参数\n",
    "W = 0.01 * np.random.randn(D,K)\n",
    "b = np.zeros((1,K))\n",
    " \n",
    "#需要自己敲定的步长和正则化系数\n",
    "step_size = 1e-0\n",
    "reg = 1e-3 #正则化系数\n",
    " \n",
    "#梯度下降迭代循环\n",
    "num_examples = X.shape[0]# =300\n",
    "for i in range(200):\n",
    " \n",
    "  # 计算类别得分, 结果矩阵为[N x K]\n",
    "  scores = np.dot(X, W) + b\n",
    " \n",
    "  # 计算类别概率\n",
    "  exp_scores = np.exp(scores)\n",
    "  probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) # #每个点分类的得分所占概率（包括正确分类和错误分类）,300*3\n",
    " \n",
    "  # 计算损失loss(包括互熵损失和正则化部分)\n",
    "  corect_logprobs = -np.log(probs[range(num_examples),y])#从y的定义可以看出y是代表这个点是哪个label的 corect_logprobs是一个array\n",
    "  data_loss = np.sum(corect_logprobs)/num_examples\n",
    "  reg_loss = 0.5*reg*np.sum(W*W)#正则化强度λ在上述代码中是reg=0.001，最开始的时候我们可能会得到loss=1.1 \n",
    "  loss = data_loss + reg_loss\n",
    "  if i % 10 == 0:\n",
    "    print (\"iteration %d: loss %f\" % (i, loss))\n",
    " \n",
    "  #我们依旧记probs为所有样本属于各个类别的概率，记dscores为得分上的梯度，我们可以有以下的代码：计算得分上的梯度\n",
    "    #下面我们将求导后的变量叫dscores\n",
    "  dscores = probs\n",
    "  dscores[range(num_examples),y] -= 1# 减去公式的最后一个部分（表示yi=k的时候，取值为1）\n",
    "  dscores /= num_examples#softmax损失函数中有个1/m，其中m为样本数量 相当于dataloss的部分\n",
    " \n",
    "  # 计算分值公式为：scores = np.dot(X, W) + b，现在求出了dscores，通过对两边分别求导，可以反推出：dW 和db\n",
    "  dW = np.dot(X.T, dscores)#将X转置一下然后和得分相乘\n",
    "  dW += reg*W # 正则化梯度\n",
    "  db = np.sum(dscores, axis=0, keepdims=True)\n",
    " \n",
    "\n",
    " \n",
    "  #参数更新\n",
    "  W += -step_size * dW#step_size = 1\n",
    "  b += -step_size * db "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training accuracy: 0.52\n"
     ]
    }
   ],
   "source": [
    "#评估准确度\n",
    "scores = np.dot(X, W) + b\n",
    "predicted_class = np.argmax(scores, axis=1)\n",
    "print( 'training accuracy: %.2f' % (np.mean(predicted_class == y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不太好，对吧？实际上也是可理解的，你想想，一份螺旋形的数据，你偏执地要用一个线性分类器去分割，不管怎么调整这个线性分类器，都非常非常困难。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "predicted_class = np.argmax(scores, axis=1)\n",
    "plt.scatter(X[:, 0], X[:, 1], c=predicted_class , s=40, cmap=plt.cm.Spectral)\n",
    "plt.show()#分类之后的图像"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "h = 0.02\n",
    "x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5\n",
    "y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
    "                     np.arange(y_min, y_max, h))\n",
    "Z = np.dot(np.c_[xx.ravel(), yy.ravel()], W) + b\n",
    "Z = np.argmax(Z, axis=1)\n",
    "Z = Z.reshape(xx.shape)\n",
    "fig = plt.figure()\n",
    "plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)\n",
    "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)\n",
    "plt.xlim(xx.min(), xx.max())\n",
    "plt.ylim(yy.min(), yy.max())\n",
    "#fig.savefig('spiral_linear.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用神经网络分类\n",
    "  \n",
    "  从刚才的例子里可以看出，一个线性分类器，在现在的数据集上效果并不好。我们知道神经网络可以做非线性的分割，那我们就试试神经网络，看看会不会有更好的效果。对于这样一个简单问题，我们用单隐藏层的神经网络就可以了，这样一个神经网络我们需要2层的权重和偏移量："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0: loss 1.098592\n",
      "iteration 1000: loss 0.285408\n",
      "iteration 2000: loss 0.257015\n",
      "iteration 3000: loss 0.243676\n",
      "iteration 4000: loss 0.241005\n",
      "iteration 5000: loss 0.240258\n",
      "iteration 6000: loss 0.239954\n",
      "iteration 7000: loss 0.239812\n",
      "iteration 8000: loss 0.239724\n",
      "iteration 9000: loss 0.239667\n"
     ]
    }
   ],
   "source": [
    "# 随机初始化参数\n",
    "h = 100 # 隐层大小 代码构建的是一个两层神经网络，第一层隐层有100个神经元，输出层有3种分类，激活函数使用的是ReLU非线性函数\n",
    "W = 0.01 * np.random.randn(D,h) #2*100\n",
    "b = np.zeros((1,h))#1*100\n",
    "W2 = 0.01 * np.random.randn(h,K)#100*3\n",
    "b2 = np.zeros((1,K))1*3\n",
    " \n",
    "# 手动敲定的几个参数\n",
    "step_size = 1e-0\n",
    "reg = 1e-3 # 正则化参数\n",
    " \n",
    "# 梯度迭代与循环\n",
    "num_examples = X.shape[0]\n",
    "for i in range(10000):\n",
    " \n",
    "  hidden_layer = np.maximum(0, np.dot(X, W) + b) #使用的ReLU神经元因为其特性，\n",
    "    #一旦x大于0,才能通过，并且倒数是一个常数，所以当我们反向传播时很简单，小于零的置0，别的不变\n",
    "  scores = np.dot(hidden_layer, W2) + b2\n",
    " \n",
    "  # 计算类别概率\n",
    "  exp_scores = np.exp(scores)\n",
    "  probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) # [N x K]\n",
    " \n",
    "  # 计算互熵损失与正则化项\n",
    "  corect_logprobs = -np.log(probs[range(num_examples),y])\n",
    "  data_loss = np.sum(corect_logprobs)/num_examples\n",
    "  reg_loss = 0.5*reg*np.sum(W*W) + 0.5*reg*np.sum(W2*W2)\n",
    "  loss = data_loss + reg_loss\n",
    "  if i % 1000 == 0:\n",
    "    print(\"iteration %d: loss %f\" % (i, loss))\n",
    " \n",
    "  # 计算梯度\n",
    "  dscores = probs\n",
    "  dscores[range(num_examples),y] -= 1\n",
    "  dscores /= num_examples\n",
    " \n",
    "  # 梯度回传\n",
    "  dW2 = np.dot(hidden_layer.T, dscores)\n",
    "  db2 = np.sum(dscores, axis=0, keepdims=True)\n",
    " \n",
    "  dhidden = np.dot(dscores, W2.T)\n",
    " \n",
    "  dhidden[hidden_layer <= 0] = 0\n",
    "  # 拿到最后W,b上的梯度\n",
    "  dW = np.dot(X.T, dhidden)\n",
    "  db = np.sum(dhidden, axis=0, keepdims=True)\n",
    " \n",
    "  # 加上正则化梯度部分\n",
    "  dW2 += reg * W2\n",
    "  dW += reg * W\n",
    " \n",
    "  # 参数迭代与更新\n",
    "  W += -step_size * dW\n",
    "  b += -step_size * db\n",
    "  W2 += -step_size * dW2\n",
    "  b2 += -step_size * db2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training accuracy: 0.99\n"
     ]
    }
   ],
   "source": [
    "#计算分类准确度\n",
    "hidden_layer = np.maximum(0, np.dot(X, W) + b)\n",
    "scores = np.dot(hidden_layer, W2) + b2\n",
    "predicted_class = np.argmax(scores, axis=1)\n",
    "print ('training accuracy: %.2f' % (np.mean(predicted_class == y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "h = 0.02\n",
    "x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n",
    "y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
    "                     np.arange(y_min, y_max, h))\n",
    "Z = np.dot(np.maximum(0, np.dot(np.c_[xx.ravel(), yy.ravel()], W) + b), W2) + b2\n",
    "Z = np.argmax(Z, axis=1)\n",
    "Z = Z.reshape(xx.shape)\n",
    "fig = plt.figure()\n",
    "plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)\n",
    "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)\n",
    "plt.xlim(xx.min(), xx.max())\n",
    "plt.ylim(yy.min(), yy.max())\n",
    "#fig.savefig('spiral_net.png')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
